import pymysql
import traceback
from dbutils.pooled_db import PooledDB

from scrapy.utils.project import get_project_settings


class MySqlUtil(object):
    # 获取scrapy中settings的信息
    settings = get_project_settings()

    config = {
        "host": settings.get("MYSQL_HOST"),
        "port": settings.get("MYSQL_PORT"),
        "database": settings.get("MYSQL_DATABASE"),
        "user": settings.get("MYSQL_USER"),
        "password": settings.get("MYSQL_PASSWORD"),
        "charset": settings.get("MYSQL_CHARSET")
    }

    """
    MYSQL数据库对象，负责产生数据库连接
    """

    # 连接池对象
    __pool = None

    def __init__(self):
        self._conn = MySqlUtil.get_conn()
        self._cursor = self._conn.cursor()

    @staticmethod
    def get_conn():
        """
        @summary: 静态方法，从连接池中取出连接
        @return： MySQLdb.connection
        """
        if MySqlUtil.__pool is None:
            __pool = PooledDB(creator=pymysql, mincached=1, maxcached=20, host=MySqlUtil.config['host'],
                              port=MySqlUtil.config['port'], user=MySqlUtil.config['user'],
                              passwd=MySqlUtil.config['password'], db=MySqlUtil.config['database'],
                              charset=MySqlUtil.config['charset'])

            return __pool.connection()

        def get_all(self, sql, param=None):
            """
            @summary: 执行查询， 并返回所有结果集
            @param sql: 查询sql，如果有查询条件，请指定参数列表，并使用[param]传入
            @param param: 可选参数，条件列表值（元组/列表）
            @return: result list(字典对象)/boolean 查询到的结果集
            """
            try:
                if param is None:
                    count = self._cursor.execute(sql)
                else:
                    count = self._cursor.execute(sql, param)
                if count > 0:
                    result = self._cursor.fetchall()
                else:
                    result = False
                return result
            except Exception as e:
                traceback.print_exc(e)

        def get_one(self, sql, param=None):
            """
            @summary: 执行查询， 并返回所有结果集
            @param sql: 查询sql，如果有查询条件，请指定参数列表，并使用[param]传入
            @param param: 可选参数，条件列表值（元组/列表）
            @return: result list/boolean 查询到的结果集
            """
            try:
                if param is None:
                    count = self._cursor.execute(sql)
                else:
                    count = self._cursor.execute(sql, param)
                if count > 0:
                    result = self._cursor.fetchone()
                else:
                    result = False
                return result
            except Exception as e:
                traceback.print_exc(e)

        def get_count(self, sql, param=None):
            """
            @summary: 执行查询， 并返回所有结果集
            @param sql: 查询sql，如果有查询条件，请指定参数列表，并使用[param]传入
            @param param: 可选参数，条件列表值（元组/列表）
            @return: result list/boolean 查询到的结果集
            """
            try:
                if param is None:
                    count = self._cursor.execute(sql)
                else:
                    count = self._cursor.execute(sql, param)
                return count
            except Exception as e:
                traceback.print_exc(e)

        def get_many(self, sql, num, param=None):
            """
            @summary: 执行查询，并取出num条结果
            @param sql:查询sql，如果有查询条件，请只指定条件列表，并将条件值使用参数[param]传递进来
            @param num:取得的结果条数
            @param param: 可选参数，条件列表值（元组/列表）
            @return: result list/boolean 查询到的结果集
            """
            try:
                if param is None:
                    count = self._cursor.execute(sql)
                else:
                    count = self._cursor.execute(sql, param)
                if count > 0:
                    result = self._cursor.fetchmany(num)
                else:
                    result = False
                return result
            except Exception as e:
                traceback.print_exc(e)

        def insert_one(self, sql, value):
            """
            @summary: 向数据表插入一条记录
            @param sql:要插入的sql格式
            @param value:要插入的记录数据tuple/list
            @return: insertId 受影响的行数
            """
            try:
                row_count = self._cursor.execute(sql, value)
                return row_count
            except Exception as e:
                traceback.print_exc(e)
                self.end("rollback")

        def insert_many(self, sql, values):
            """
            @summary: 向数据表插入多条记录
            @param sql:要插入的sql格式
            @param values:要插入的记录数据tuple(tuple)/list[list]
            @return: count 受影响的行数
            """
            try:
                row_count = self._cursor.executemany(sql, values)
                return row_count
            except Exception as e:
                traceback.print_exc(e)
                self.end("rollback")

        def __query(self, sql, param=None):
            try:
                if param is None:
                    count = self._cursor.execute(sql)
                else:
                    count = self._cursor.execute(sql, param)
                return count
            except Exception as e:
                traceback.print_exc(e)

        def update(self, sql, param=None):
            """
            @summary: 更新数据表记录
            @param sql: sql格式及条件，使用(%s,%s)
            @param param: 要更新的  值 tuple/list
            @return: count 受影响的行数
            """
            return self.__query(sql, param)

        def delete(self, sql, param=None):
            """
            @summary: 删除数据表记录
            @param sql: sql格式及条件，使用(%s,%s)
            @param param: 要删除的条件 值 tuple/list
            @return: count 受影响的行数
            """
            return self.__query(sql, param)

        def begin(self):
            """
            @summary: 开启事务
            """
            self._conn.autocommit(0)

        def end(self, option='commit'):
            """
            @summary: 结束事务
            """
            if option == 'commit':
                self._conn.commit()
            else:
                self._conn.rollback()

        def dispose(self, is_end=1):
            """
            @summary: 释放连接池资源
            """
            if is_end == 1:
                self.end('commit')
            else:
                self.end('rollback')
            self._cursor.close()
            self._conn.close()
